package com.cookiesoft.game.service.impl;

import java.util.List;
        import com.cookiesoft.common.utils.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
    import java.util.ArrayList;

    import com.cookiesoft.common.utils.StringUtils;
    import org.springframework.transaction.annotation.Transactional;
    import com.cookiesoft.game.domain.ZhenAccount;
import com.cookiesoft.game.mapper.ZhenCategoryMapper;
import com.cookiesoft.game.domain.ZhenCategory;
import com.cookiesoft.game.service.IZhenCategoryService;

/**
 * 游戏类别，存储游戏分类信息Service业务层处理
 *
 * @author anc
 * @date 2024-11-05
 */
@Service
public class ZhenCategoryServiceImpl implements IZhenCategoryService {
    @Autowired
    private ZhenCategoryMapper zhenCategoryMapper;

    /**
     * 查询游戏类别，存储游戏分类信息
     *
     * @param categoryId 游戏类别，存储游戏分类信息主键
     * @return 游戏类别，存储游戏分类信息
     */
    @Override
    public ZhenCategory selectZhenCategoryByCategoryId(Long categoryId) {
        return zhenCategoryMapper.selectZhenCategoryByCategoryId(categoryId);
    }

    /**
     * 查询游戏类别，存储游戏分类信息列表
     *
     * @param zhenCategory 游戏类别，存储游戏分类信息
     * @return 游戏类别，存储游戏分类信息
     */
    @Override
    public List<ZhenCategory> selectZhenCategoryList(ZhenCategory zhenCategory) {
        return zhenCategoryMapper.selectZhenCategoryList(zhenCategory);
    }

    /**
     * 新增游戏类别，存储游戏分类信息
     *
     * @param zhenCategory 游戏类别，存储游戏分类信息
     * @return 结果
     */
        @Transactional
    @Override
    public int insertZhenCategory(ZhenCategory zhenCategory) {
            zhenCategory.setCreateTime(DateUtils.getNowDate());
            int rows = zhenCategoryMapper.insertZhenCategory(zhenCategory);
            insertZhenAccount(zhenCategory);
            return rows;
    }

    /**
     * 修改游戏类别，存储游戏分类信息
     *
     * @param zhenCategory 游戏类别，存储游戏分类信息
     * @return 结果
     */
        @Transactional
    @Override
    public int updateZhenCategory(ZhenCategory zhenCategory) {
                zhenCategory.setUpdateTime(DateUtils.getNowDate());
                zhenCategoryMapper.deleteZhenAccountByCategoryId(zhenCategory.getCategoryId())
            ;
            insertZhenAccount(zhenCategory);
        return zhenCategoryMapper.updateZhenCategory(zhenCategory);
    }

    /**
     * 批量删除游戏类别，存储游戏分类信息
     *
     * @param categoryIds 需要删除的游戏类别，存储游戏分类信息主键
     * @return 结果
     */
        @Transactional
    @Override
    public int deleteZhenCategoryByCategoryIds(Long[] categoryIds) {
                zhenCategoryMapper.deleteZhenAccountByCategoryIds(categoryIds);
        return zhenCategoryMapper.deleteZhenCategoryByCategoryIds(categoryIds);
    }

    /**
     * 删除游戏类别，存储游戏分类信息信息
     *
     * @param categoryId 游戏类别，存储游戏分类信息主键
     * @return 结果
     */
        @Transactional
    @Override
    public int deleteZhenCategoryByCategoryId(Long categoryId) {
                zhenCategoryMapper.deleteZhenAccountByCategoryId(categoryId);
        return zhenCategoryMapper.deleteZhenCategoryByCategoryId(categoryId);
    }

        /**
         * 新增游戏账号，存储用户的游戏账号信息信息
         *
         * @param zhenCategory 游戏类别，存储游戏分类信息对象
         */
        public void insertZhenAccount(ZhenCategory zhenCategory) {
            List<ZhenAccount> zhenAccountList = zhenCategory.getZhenAccountList();
            Long categoryId = zhenCategory.getCategoryId();
            if (StringUtils.isNotNull(zhenAccountList)) {
                List<ZhenAccount> list = new ArrayList<ZhenAccount>();
                for (ZhenAccount zhenAccount :zhenAccountList)
                {
                    zhenAccount.setCategoryId(categoryId);
                    list.add(zhenAccount);
                }
                if (list.size() > 0) {
                        zhenCategoryMapper.batchZhenAccount(list);
                }
            }
        }
}
